﻿#define _CRT_SECURE_NO_WARNINGS 1
//句子 是一个单词列表，列表中的单词之间用单个空格隔开，且不存在前导或尾随空格。每个单词仅由大小写英文字母组成（不含标点符号）。
//
//例如，"Hello World"、"HELLO" 和 "hello world hello world" 都是句子。
//给你一个句子 s​​​​​​ 和一个整数 k​​​​​​ ，请你将 s​​ 截断 ​，​​​使截断后的句子仅含 前 k​​​​​​ 个单词。返回 截断 s​​​​​​ 后得到的句子。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/truncate-sentence
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//char * truncateSentence(char * s, int k){
//	char*p = s;
//	while (*p)
//	{
//		if (*p == ' '&&--k == 0)
//		{
//			*p = '\0';
//			return s;
//		}
//		p++;
//	}
//	return s;
//}







//给你一个字符串 s ，将该字符串中的大写字母转换成相同的小写字母，返回新的字符串。
//char * toLowerCase(char * s){
//	int len = strlen(s);
//	int i = 0;
//	for (i = 0; i<len; i++)
//	{
//		if (s[i] >= 'A'&&s[i] <= 'Z')
//		{
//			s[i] -= 'A' - 'a';
//		}
//	}
//	return s;
//}







/**给定两个数组，编写一个函数来计算它们的交集
* Note: The returned array must be malloced, assume caller calls free().
*/
//int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
//	int a[1024] = { 0 };
//	int i = 0;
//	int j = 0;
//	int k = 0;
//	for (i = 0; i<nums1Size; i++)
//	{
//		a[nums1[i]] = 1;
//	}
//	int* b = (int*)calloc(sizeof(int), nums2Size);
//	for (j = 0; j<nums2Size; j++)
//	{
//		if (a[nums2[j]])
//		{
//			b[k++] = nums2[j];
//			a[nums2[j]] = 0;
//		}
//	}
//	*returnSize = k;
//	int *ret = (int*)malloc(sizeof(int)*k);
//	for (i = 0; i<k; i++)
//	{
//		ret[i] = b[i];
//	}
//	return ret;
//}








//给你一个整数 n，请你返回一个含 n 个字符的字符串，其中每种字符在该字符串中都恰好出现 奇数次 。
//返回的字符串必须只含小写英文字母。如果存在多个满足题目要求的字符串，则返回其中任意一个即可。
//char * generateTheString(int n){
//	char* ret = (char*)calloc(sizeof(char), n + 1);
//	int i = 0;
//	for (i = 0; i<n; i++)
//	{
//		ret[i] = 'a';
//	}
//	if (n % 2 == 0)
//	{
//		ret[strlen(ret) - 1] = 'b';
//	}
//	return ret;
//}







//如果一个字符串不含有任何重复字符，我们称这个字符串为 好 字符串。
//给你一个字符串 s ，请你返回 s 中长度为 3 的 好子字符串 的数量。
//注意，如果相同的好子字符串出现多次，每一次都应该被记入答案之中。
//子字符串 是一个字符串中连续的字符序列。
//int countGoodSubstrings(char * s){
//	int count = 0;
//	int len = strlen(s);
//	int i = 0;
//	int j = 0;
//	for (i = 0; i<len - 2; i++)
//	{
//		if (s[i] != s[i + 1] && s[i] != s[i + 2] && s[i + 1] != s[i + 2])
//		{
//			count++;
//		}
//	}
//	return count;
//}








//编写一个方法，找出两个数字a和b中最大的那一个。不得使用if - else或其他比较运算符。
//int maximum(int a, int b){
//	long c = a;
//	long d = b;
//	long x = 1 + ((c - d) >> 63);
//	return a*x + (!x)*b;
//}








/**给你一个整数数组 arr 。请你将数组中的元素按照其二进制表示中数字 1 的数目升序排序。

如果存在多个数字二进制中 1 的数目相同，则必须将它们按照数值大小升序排列。

请你返回排序后的数组。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sort-integers-by-the-number-of-1-bits
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
* Note: The returned array must be malloced, assume caller calls free().
*/
//int add(int n)
//{
//	int count = 0;
//	while (n)
//	{
//		if (n % 2 == 1)
//		{
//			count++;
//		}
//		n /= 2;
//	}
//	return count;
//}
//int cmp(const void *a, const void *b)
//{
//	int num1 = *(int*)a;
//	int num2 = *(int*)b;
//	int c = add(num1);
//	int d = add(num2);
//	return c == d ? num1 - num2 : c - d;
//}
//int* sortByBits(int* arr, int arrSize, int* returnSize){
//	*returnSize = arrSize;
//	qsort(arr, arrSize, sizeof(int), cmp);
//	return arr;
//}








//请实现一个函数，输入一个整数（以二进制串形式），输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/er-jin-zhi-zhong-1de-ge-shu-lcof
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int hammingWeight(uint32_t n) {
//	int count = 0;
//	while (n)
//	{
//		if (n % 2 == 1)
//		{
//			count++;
//		}
//		n /= 2;
//	}
//	return count;
//}







/**给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
* Note: The returned array must be malloced, assume caller calls free().
*/
//int* sortedSquares(int* nums, int numsSize, int* returnSize){
//	*returnSize = numsSize;
//	int* a = (int*)malloc(sizeof(int)*numsSize);
//	int i = 0;
//	int tmp = 0;
//	int j = 0;
//	int k = 0;
//	for (i = 0; i<numsSize; i++)
//	{
//		a[k++] = nums[i] * nums[i];
//	}
//	for (i = 0; i<numsSize; i++)
//	{
//		for (j = 0; j<numsSize - i - 1; j++)
//		{
//			if (a[j]>a[j + 1])
//			{
//				tmp = a[j];
//				a[j] = a[j + 1];
//				a[j + 1] = tmp;
//			}
//		}
//	}
//	return a;
//}







/**给你一个整数 n，请你返回 任意 一个由 n 个 各不相同 的整数组成的数组，并且这 n 个数相加和为 0 。
* Note: The returned array must be malloced, assume caller calls free().
*/
//int* sumZero(int n, int* returnSize){
//	int*a = (int*)malloc(n*sizeof(int));
//	*returnSize = n;
//	int num = 0;
//	int len = n - 1;
//	int i = 0;
//	for (i = 0; i<len; i++)
//	{
//		a[i] = ++num;
//	}
//	a[len] = -(1 + len)*len / 2;
//	return a;
//}